/**
 * 
 */
package platzerworld.kegeln.db.spieler;

import java.util.ArrayList;
import java.util.List;

import platzerworld.kegeln.common.db.Sortierung;
import platzerworld.kegeln.common.logging.LOG;
import platzerworld.kegeln.db.KegelverwaltungDatenbank;
import platzerworld.kegeln.vo.spieler.SpielerVO;
import android.content.ContentValues;
import android.content.Context;
import android.database.Cursor;
import android.database.sqlite.SQLiteDatabase;
import android.database.sqlite.SQLiteQueryBuilder;
import android.util.Log;

/**
 * Der SpielerSpeicher ist die Schnittstelle zu persistenten Spielerdaten.
 * Die Spielerdaten sind in der Anwendungsdatenbank abgelegt. Die Anwendung sollte nur über den SpielerSpeicher auf gespeicherte Daten zugreifen.
 * Um den SpielerSpeicher erzeugen zu können, muss die aufrufende Android-Komponente ihren Context übergeben.
 * 
 * @author platzerg
 */
public class SpielerSpeicher {

	/** Markierung für Logging. */
	private static final String TAG = "SpielerSpeicher";

	/** Verweis auf die Kegelverwaltung-Datenbank. */
	private KegelverwaltungDatenbank mDb;

	/**
	 * Erzeugt einen neuen SpielerSpeicher. 
	 * Dabei wird sichergestellt, dass die zugrundeliegende Datenbank unmittelbar nutzbar ist.
	 * 
	 * @param context Kontext der Anwendung, für die der Speicher gültig sein soll.
	 */
	public SpielerSpeicher(Context context) {
		mDb = new KegelverwaltungDatenbank(context);
		LOG.v(TAG, "Spielerspeicher angelegt.");
	}

	/**
	 * Erzeugung ohne Context nicht möglich.
	 */
	private SpielerSpeicher() {
	}
	
	/**
	 * Speicherung eines Spielers.
	 * 
	 * @param spielerVO enthält die Daten des Spielers
	 * @param isUpdate true dann update sonst insert
	 * 
	 * @return key Spieler
	 */
	public long speichereSpieler(SpielerVO spielerVO) {
		if (spielerVO.istNeu()) {
			return speichereSpielerAllColumns(spielerVO);
		} else {
			aendereSpielerAllColumns(spielerVO);
			return spielerVO.id;
		}
	}
	
	/**
	 * Legt einen neuen Spieler in der Datenbank an.
	 * 
	 * @param spielerVO enthält die Daten des Spielers
	 * 
	 * @return key SpielerVO
	 */
	private long speichereSpielerAllColumns(SpielerVO spielerVO) {

		final ContentValues daten = new ContentValues();
		daten.put(SpielerTbl.MANNSCHAFT_ID, spielerVO.mannschaftId);
		daten.put(SpielerTbl.AUSHELFER_MANNSCHAFT_ID, spielerVO.aushelfermannschaftId);
		daten.put(SpielerTbl.PASS_NR, spielerVO.passNr);
		daten.put(SpielerTbl.NAME, spielerVO.name);
		daten.put(SpielerTbl.VORNAME, spielerVO.vorname);
		daten.put(SpielerTbl.GEB_DATUM, spielerVO.gebDatum);
		daten.put(SpielerTbl.LOC_LATITUDE, spielerVO.latidute);
		daten.put(SpielerTbl.LOC_LONGITUDE, spielerVO.longitude);

		final SQLiteDatabase dbCon = mDb.getWritableDatabase();

		try {
			final long id = dbCon.insertOrThrow(SpielerTbl.TABLE_NAME, null, daten);
			Log.i(TAG, "Spieler mit id=" + id + " erzeugt.");
			return id;
		} finally {
			dbCon.close();
		}
	}
	
	/**
	 * Ändert einen vorhandenen Spieler in der Datenbank. 
	 * Wenn die id nicht mitgegeben wird, wird keine Änderung durchgeführt. 
	 * Es werden bei der Änderung alle Parameter berücksichtigt.
	 * 
	 * @param spielerVO enthält die Daten des Spielers
	 */
	private void aendereSpielerAllColumns(SpielerVO spielerVO) {
		if (spielerVO.istNeu()) {
			Log.w(TAG, "id == 0 => kein update möglich.");
			return;
		}

		final ContentValues daten = new ContentValues();
		daten.put(SpielerTbl.MANNSCHAFT_ID, spielerVO.mannschaftId);
		daten.put(SpielerTbl.AUSHELFER_MANNSCHAFT_ID, spielerVO.aushelfermannschaftId);
		daten.put(SpielerTbl.PASS_NR, spielerVO.passNr);
		daten.put(SpielerTbl.NAME, spielerVO.name);
		daten.put(SpielerTbl.VORNAME, spielerVO.vorname);
		daten.put(SpielerTbl.GEB_DATUM, spielerVO.gebDatum);
		daten.put(SpielerTbl.LOC_LATITUDE, spielerVO.latidute);
		daten.put(SpielerTbl.LOC_LONGITUDE, spielerVO.longitude);

		final SQLiteDatabase dbCon = mDb.getWritableDatabase();

		try {
			dbCon.update(SpielerTbl.TABLE_NAME, daten, SpielerTbl.WHERE_ID_EQUALS, new String[] { String.valueOf(spielerVO.id) });
			Log.i(TAG, "Spieler id=" + spielerVO.id + " aktualisiert.");
		} finally {
			dbCon.close();
		}
	}

	/**
	 * Entfernt einen Spieler aus der Datenbank.
	 * 
	 * @param id Schlüssel des gesuchten Spielers
	 * @return true, wenn Datensatz geloescht wurde.
	 */
	public boolean loescheSpielerById(long id) {
		final SQLiteDatabase dbCon = mDb.getWritableDatabase();

		int anzahlLoeschungen = 0;
		try {
			anzahlLoeschungen = dbCon.delete(SpielerTbl.TABLE_NAME, SpielerTbl.WHERE_ID_EQUALS,
					new String[] { String.valueOf(id) });
			Log.i(TAG, "Spieler id=" + id + " gelöscht.");
		} finally {
			dbCon.close();
		}
		return anzahlLoeschungen == 1;
	}
	
	/**
	 * Entfernt alle Spieler zur mannschafts_id aus der Datenbank.
	 * 
	 * @param mannschaftId Mannschafts-ID
	 * @return true, wenn Datensatz geloescht wurde.
	 */
	public boolean loescheAlleSpielerZurMannschaft(long mannschaftId) {
		final SQLiteDatabase dbCon = mDb.getWritableDatabase();

		int anzahlLoeschungen = 0;
		try {
			anzahlLoeschungen = dbCon.delete(SpielerTbl.TABLE_NAME, SpielerTbl.WHERE_ID_MANNSCHAFT_EQUALS,
					new String[] { String.valueOf(mannschaftId) });
			Log.i(TAG, "Spieler mannschaftId=" + mannschaftId + " gelöscht.");
		} finally {
			dbCon.close();
		}
		return anzahlLoeschungen == 1;
	}

	/**
	 * Liefert einen Cursor zur ID auf alle Felder der Spieler-Tabelle zurück.
	 * 
	 * @param id Schlüssel des gesuchten Spielers
	 * 
	 * @return Cursor, oder null
	 */
	public Cursor ladeSpielerDetails(long id) {
		return mDb.getReadableDatabase().query(SpielerTbl.TABLE_NAME, SpielerTbl.ALL_COLUMNS,
				SpielerTbl.WHERE_ID_EQUALS, new String[] { String.valueOf(id) }, null, null, null);
	}

	/**
	 * Liefert ein Value-Object SpielerVO zur id mit allen Feldern der Spieler-Tabelle zurück.
	 * 
	 * @param id Schlüssel des gesuchten Spielers
	 * 
	 * @return WettkampfVO, oder null
	 */
	public SpielerVO ladeSpielerVO(long id) {
		SpielerVO kontakt = null;
		Cursor c = null;
		try {
			c = mDb.getReadableDatabase().query(SpielerTbl.TABLE_NAME, SpielerTbl.ALL_COLUMNS,
					SpielerTbl.WHERE_ID_EQUALS, new String[] { String.valueOf(id) }, null, null, null);
			if (c.moveToFirst() == false) {
				return null;
			}
			kontakt = ladeSpieler(c);
		} finally {
			if (c != null) {
				c.close();
			}
		}
		return kontakt;
	}

	/**
	 * Liefert einen Cursor zum Namen auf alle Felder der Spieler-Tabelle zurück.
	 * 
	 * @param name Name des gesuchten Spielers
	 * 
	 * @return Cursor, oder null
	 */
	public Cursor ladeSpielerDetails(String name) {
		if (name == null) {
			return null;
		}
		return mDb.getReadableDatabase().query(SpielerTbl.TABLE_NAME, SpielerTbl.ALL_COLUMNS, SpielerTbl.WHERE_NAME_EQUALS,
				new String[] { name }, null, null, SpielerTbl.DEFAULT_SORT_ORDER);
	}

	/**
	 * Liefert alle SpielerVO's sortiert nach Name zurück.
	 * 
	 * Es kann (optional) ein Filterkriterium angegeben werden. 
	 * Wenn dernamensFilterdefiniert ist, werden nur Spieler geliefert, deren NAME mit diesem Buchstaben beginnt.
	 * 
	 * @param namensFilter Anfangsbuchstaben (case sensitive) des zu suchenden Vereins.
	 * 
	 * @return Cursor auf die Ergebnisliste.
	 */
	public Cursor ladeSpielerListe(CharSequence namensFilter) {
		return ladeSpielerListe(Sortierung.STANDARD, namensFilter);
	}

	/**
	 * Liefert alle Spieler mit einstellbarer Sortierung zurück.
	 * Es kann (optional) ein Filterkriterium angegeben werden. Wenn der namensFilter definiert ist, 
	 * werden nur Spieler geliefert, deren NAME mit diesem Buchstaben beginnt.
	 * 
	 * @param sortierung Art der Sortierung
	 * @param namensFilter  Anfangsbuchstaben (case sensitive) der zu suchenden Spieler.
	 * @return Cursor auf die Ergebnisliste.
	 */
	public Cursor ladeSpielerListe(Sortierung sortierung, CharSequence namensFilter) {
		final SQLiteQueryBuilder spielerSuche = new SQLiteQueryBuilder();
		spielerSuche.setTables(SpielerTbl.TABLE_NAME);
		String[] whereAttribs = null;
		if (namensFilter != null && namensFilter.length() > 0) {
			spielerSuche.appendWhere(SpielerTbl.WHERE_NAME_LIKE);
			whereAttribs = new String[] { namensFilter + "%" };
		}

		return spielerSuche.query(mDb.getReadableDatabase(), SpielerTbl.ALL_COLUMNS, null, whereAttribs, null, null,
				getSpielerSortierung(sortierung));
	}
	
	/**
	 * Liefert ein Value-Object SpielerVO zur id mit allen Feldern der Spieler-Tabelle zurück.
	 * 
	 * @param sortierung Art der Sortierung
	 * @param namensFilter  Anfangsbuchstaben (case sensitive) der zu suchenden Spieler.
	 * 
	 * @return SpielerVO, oder null
	 */
	public ArrayList<SpielerVO> ladeSpielerBySuchkriterium(Sortierung sortierung, SpielerVO spielerVOSearch) {
		ArrayList<SpielerVO> spielerVOs = new ArrayList<SpielerVO>();
		SpielerVO spielerVO = null;
		Cursor c = null;
		
		final SQLiteQueryBuilder spielerSuche = new SQLiteQueryBuilder();
		spielerSuche.setTables(SpielerTbl.TABLE_NAME);
		
		List<String> searchQuery = new ArrayList<String>();
		
		
		
		if(null != spielerVOSearch){
			spielerSuche.appendWhere("_id > 0");
			
			if (spielerVOSearch.mannschaftId  > 0) {
				spielerSuche.appendWhere(SpielerTbl.AND_WHERE_MANNSCHAFT_ID_EQUALS);
				searchQuery.add( String.valueOf(spielerVOSearch.mannschaftId));
			}
			
			if (spielerVOSearch.passNr  > 0) {
				spielerSuche.appendWhere(SpielerTbl.AND_WHERE_PASSNR_EQUALS);
				searchQuery.add( String.valueOf(spielerVOSearch.passNr));
			}
			
			if (spielerVOSearch.name  != null && spielerVOSearch.name .length() > 0) {
				spielerSuche.appendWhere(SpielerTbl.AND_WHERE_NAME_LIKE);
				searchQuery.add( spielerVOSearch.name  + "%" );
			}
			
			if (spielerVOSearch.vorname  != null && spielerVOSearch.vorname .length() > 0) {
				spielerSuche.appendWhere(SpielerTbl.AND_WHERE_VORNAME_LIKE);
				searchQuery.add( spielerVOSearch.vorname  + "%" );
			}
			
			String[] queryPar = searchQuery.toArray(new String[searchQuery.size()]);  
			
			
			try {
				c = spielerSuche.query(mDb.getReadableDatabase(), SpielerTbl.ALL_COLUMNS, null, queryPar, null, null,
						getSpielerSortierung(Sortierung.NAME));
				
				if (c != null ) {
		    		if  (c.moveToFirst()) {
		    			do {    				
		    				spielerVO= new SpielerVO();    				
		    				spielerVO.key = c.getLong(c.getColumnIndex(SpielerTbl.ID));
		    				spielerVO.id = c.getLong(c.getColumnIndex(SpielerTbl.ID));
		    				spielerVO.name = c.getString(c.getColumnIndex(SpielerTbl.NAME));    
		    				spielerVO.value = c.getString(c.getColumnIndex(SpielerTbl.NAME));
		    				spielerVO.mannschaftId = c.getLong(c.getColumnIndex(SpielerTbl.MANNSCHAFT_ID));
		    				spielerVO.aushelfermannschaftId = c.getLong(c.getColumnIndex(SpielerTbl.AUSHELFER_MANNSCHAFT_ID));
		    				
		    				spielerVO.passNr = c.getLong(c.getColumnIndex(SpielerTbl.PASS_NR));
		    				spielerVO.vorname = c.getString(c.getColumnIndex(SpielerTbl.VORNAME));
		    				spielerVO.gebDatum = c.getString(c.getColumnIndex(SpielerTbl.GEB_DATUM));
		    				
		    				spielerVO.latidute = c.getInt(c.getColumnIndex(SpielerTbl.LOC_LATITUDE));
		    				spielerVO.longitude = c.getInt(c.getColumnIndex(SpielerTbl.LOC_LONGITUDE));
		    				
		    				spielerVOs.add(spielerVO);
		    			}while (c.moveToNext());
		    		} 
		    	}
			} finally {
				if (c != null) {
					c.close();
				}
			}
		}
		
		
		return spielerVOs;
	}
	
	/**
	 * Liefert ein Value-Object SpielerVO zur id mit allen Feldern der Spieler-Tabelle zurück.
	 * 
	 * @param sortierung Art der Sortierung
	 * @param namensFilter  Anfangsbuchstaben (case sensitive) der zu suchenden Spieler.
	 * 
	 * @return SpielerVO, oder null
	 */
	public SpielerVO ladeSpielerByName(Sortierung sortierung, CharSequence namensFilter) {
		SpielerVO spielerVO = null;
		Cursor c = null;
		
		final SQLiteQueryBuilder spielerSuche = new SQLiteQueryBuilder();
		spielerSuche.setTables(SpielerTbl.TABLE_NAME);
		String[] whereAttribs = null;
		if (namensFilter != null && namensFilter.length() > 0) {
			spielerSuche.appendWhere(SpielerTbl.WHERE_NAME_LIKE);
			whereAttribs = new String[] { namensFilter + "%" };
		}
		
		try {
			c = spielerSuche.query(mDb.getReadableDatabase(), SpielerTbl.ALL_COLUMNS, null, whereAttribs, null, null,
					getSpielerSortierung(Sortierung.NAME));
			
			if (c.moveToFirst() == false) {
				return null;
			}
			spielerVO = ladeSpieler(c);
		} finally {
			if (c != null) {
				c.close();
			}
		}
		
		return spielerVO;
	}
	
	/**
	 * Liefert alle Spieler zur mannschafts_id mit einstellbarer Sortierung zurück.
	 * Es kann (optional) ein Filterkriterium angegeben werden. Wenn der namensFilter definiert ist, 
	 * werden nur Spieler geliefert, deren NAME mit diesem Buchstaben beginnt.
	 * 
	 * @param namensFilter Anfangsbuchstaben (case sensitive) der zu suchenden Spieler.
	 * @param mannschaftId die Mannschafts-ID
	 * @return Cursor auf die Ergebnisliste.
	 */
	public Cursor ladeSpielerListeZurMannschaft(CharSequence namensFilter, long mannschaftId) {
		return ladeSpielerListeZurMannschaft(Sortierung.ID, namensFilter, mannschaftId);
	}
	
	/**
	 * Liefert alle Spieler zur mannschafts_id mit einstellbarer Sortierung zurück.
	 * Es kann (optional) ein Filterkriterium angegeben werden. Wenn der namensFilter definiert ist, 
	 * werden nur Spieler geliefert, deren NAME mit diesem Buchstaben beginnt.
	 * 
	 * @param sortierung Art der Sortierung
	 * @param namensFilter Anfangsbuchstaben (case sensitive) der zu suchenden Spieler.
	 * @param mannschaftId die Mannschafts-ID
	 * @return Cursor auf die Ergebnisliste.
	 */
	public Cursor ladeSpielerListeZurMannschaft(Sortierung sortierung, CharSequence namensFilter, long mannschaftId) {
		SQLiteDatabase d = mDb.getReadableDatabase();
		Cursor spielerCursor = d.query(SpielerTbl.TABLE_NAME, 
				SpielerTbl.ALL_COLUMNS, 
				SpielerTbl.MANNSCHAFT_ID + "=" + String.valueOf(mannschaftId), null, null, null, null);
		
		return spielerCursor;
	}
	
	/**
	 * Liefert alle Spieler zur mannschats_id mit einstellbarer Sortierung zurück.
	 * 
	 * @param mannschaftId Mannschafts-ID

	 * @return ArrayList<SpielerVO> spieler
	 */
	public ArrayList<SpielerVO> ladeAlleSpielerListeZurMannschaftVO(long mannschaftId) {
		return ladeSpielerListeZurMannschaftVO(Sortierung.ID, null, mannschaftId);
	}
	
	/**
	 * Liefert alle Spieler zur mannschats_id mit einstellbarer Sortierung zurück.
	 * 
	 * @param mannschaftId Mannschafts-ID

	 * @return ArrayList<SpielerVO> spieler
	 */
	public ArrayList<SpielerVO> ladeAlleSpielerListeZurMannschaftAndAushelferVO(long mannschaftId) {
		return ladeSpielerListeZurMannschaftAndAushelferVO(Sortierung.ID, null, mannschaftId);
	}
	
	/**
	 * Liefert alle Spieler zur mannschats_id mit einstellbarer Sortierung zurück.
	 * 
	 * @param mannschaftId Mannschafts-ID

	 * @return ArrayList<SpielerVO> spieler
	 */
	public ArrayList<SpielerVO> ladeSpielerListeZurMannschaftVO(CharSequence namensFilter, long mannschaftId) {
		return ladeSpielerListeZurMannschaftVO(Sortierung.ID, namensFilter, mannschaftId);
	}
	
	/**
	 * Liefert alle Spieler zur mannschats_id mit einstellbarer Sortierung zurück.
	 * 
	 * @param mannschaftId Mannschafts-ID

	 * @return ArrayList<SpielerVO> spieler
	 */
	public ArrayList<SpielerVO> ladeSpielerListeZurMannschaftVO(Sortierung sortierung, CharSequence namensFilter, long mannschaftId) {
		ArrayList<SpielerVO> spielerVOs = null;
		Cursor spielerCursor = null;
		SQLiteDatabase d = null;
		try{
			d = mDb.getReadableDatabase();
			spielerCursor = d.query(SpielerTbl.TABLE_NAME, 
					SpielerTbl.ALL_COLUMNS, 
					SpielerTbl.MANNSCHAFT_ID + "=" + String.valueOf(mannschaftId), null, null, null, null);
			
			spielerVOs = ladeSpielerKeyValueVO(spielerCursor);
		} finally {
			if (spielerCursor != null) {
				spielerCursor.close();
			}
			if(d.isOpen()){
				d.close();
			}
		}
		
		
		
		return spielerVOs;
	}
	
	/**
	 * Liefert alle Spieler zur mannschats_id mit einstellbarer Sortierung zurück.
	 * 
	 * @param mannschaftId Mannschafts-ID

	 * @return ArrayList<SpielerVO> spieler
	 */
	public ArrayList<SpielerVO> ladeSpielerListeZurMannschaftAndAushelferVO(Sortierung sortierung, CharSequence namensFilter, long mannschaftId) {
		ArrayList<SpielerVO> spielerVOs = null;
		Cursor spielerCursor = null;
		SQLiteDatabase d = null;
		try{
			d = mDb.getReadableDatabase();
			spielerCursor = d.query(SpielerTbl.TABLE_NAME, 
					SpielerTbl.ALL_COLUMNS, 
					SpielerTbl.MANNSCHAFT_ID + " = " + String.valueOf(mannschaftId) +" OR " +
					SpielerTbl.AUSHELFER_MANNSCHAFT_ID + " = " + String.valueOf(mannschaftId), null, null, null, null);
			
			spielerVOs = ladeSpielerKeyValueVO(spielerCursor);
		} finally {
			if (spielerCursor != null) {
				spielerCursor.close();
			}
			if(d.isOpen()){
				d.close();
			}
		}
		
		
		
		return spielerVOs;
	}
	
	/**
	 * Lädt die Spieler aus dem SpielerTbl-Datensatz, auf dem der Cursor gerade steht.
	 * Der Cursor wird anschließend deaktiviert, da er im SpielerSpeicher nur intern als "letzter Aufruf" aufgerufen wird.
	 * 
	 * @param c aktuelle Cursorposition
	 * 
	 * @return ArrayList<SpielerVO> spieler
	 */
	public ArrayList<SpielerVO> ladeSpielerKeyValueVO(Cursor c) {	
		ArrayList<SpielerVO> spielerVOs = new ArrayList<SpielerVO>();
		SpielerVO spielerVO = null;
		
		try{
			if (c != null ) {
	    		if  (c.moveToFirst()) {
	    			do {    				
	    				spielerVO= new SpielerVO();    				
	    				spielerVO.key = c.getLong(c.getColumnIndex(SpielerTbl.ID));
	    				spielerVO.id = c.getLong(c.getColumnIndex(SpielerTbl.ID));
	    				spielerVO.name = c.getString(c.getColumnIndex(SpielerTbl.NAME));    
	    				spielerVO.value = c.getString(c.getColumnIndex(SpielerTbl.NAME));
	    				spielerVO.mannschaftId = c.getLong(c.getColumnIndex(SpielerTbl.MANNSCHAFT_ID));
	    				spielerVO.aushelfermannschaftId = c.getLong(c.getColumnIndex(SpielerTbl.AUSHELFER_MANNSCHAFT_ID));
	    				
	    				spielerVO.passNr = c.getLong(c.getColumnIndex(SpielerTbl.PASS_NR));
	    				spielerVO.vorname = c.getString(c.getColumnIndex(SpielerTbl.VORNAME));
	    				spielerVO.gebDatum = c.getString(c.getColumnIndex(SpielerTbl.GEB_DATUM));
	    				
	    				spielerVO.latidute = c.getInt(c.getColumnIndex(SpielerTbl.LOC_LATITUDE));
	    				spielerVO.longitude = c.getInt(c.getColumnIndex(SpielerTbl.LOC_LONGITUDE));
	    				
	    				spielerVOs.add(spielerVO);
	    			}while (c.moveToNext());
	    		} 
	    	}
		} finally {
			if (c != null) {
				c.close();
			}
		}
		

		return spielerVOs;
	}
	
	/**
	 * Lädt die Spieler aus dem SpielerTbl-Datensatz, auf dem der Cursor gerade steht.
	 * Der Cursor wird anschließend deaktiviert, da er im Spielerpeicher nur intern als "letzter Aufruf" aufgerufen wird.
	 * 
	 * @return List<String[]> spieler als String-Array
	 */
	public List<String[]> ladeSpielerAsStringArray() {
		Cursor c = ladeSpielerListe(null);
		List<String[]> spielerAsArray = new ArrayList<String[]>();
		try{
			if (c != null ) {
	    		if  (c.moveToFirst()) {
	    			do {    	
	    				String[] spielerZeile = new String[9];
	    				// ID, PASS_NR, MANNSCHAFT_ID, AUSHELFER_MANNSCHAFT_ID, NAME, VORNAME, GEB_DATUM, LOC_LATITUDE, LOC_LONGITUDE
	    				spielerZeile[0] = String.valueOf(c.getLong(c.getColumnIndex(SpielerTbl.ID)));
	    				spielerZeile[1] = String.valueOf(c.getLong(c.getColumnIndex(SpielerTbl.PASS_NR)));
	    				spielerZeile[2] = String.valueOf(c.getLong(c.getColumnIndex(SpielerTbl.MANNSCHAFT_ID)));
	    				spielerZeile[3] = String.valueOf(c.getLong(c.getColumnIndex(SpielerTbl.AUSHELFER_MANNSCHAFT_ID)));
	    				spielerZeile[4] = c.getString(c.getColumnIndex(SpielerTbl.NAME));
	    				spielerZeile[5] = c.getString(c.getColumnIndex(SpielerTbl.VORNAME));
	    				spielerZeile[6] = c.getString(c.getColumnIndex(SpielerTbl.GEB_DATUM));
	    				spielerZeile[7] = String.valueOf(c.getInt(c.getColumnIndex(SpielerTbl.LOC_LATITUDE)));
	    				spielerZeile[8] = String.valueOf(c.getInt(c.getColumnIndex(SpielerTbl.LOC_LONGITUDE)));
	    				
	    				
	    				spielerAsArray.add(spielerZeile);
	    			}while (c.moveToNext());
	    		} 
	    	}
		} finally {
			if (c != null) {
				c.close();
			}
		}

		return spielerAsArray;
	}

	/**
	 * Liefert die Sortierung unter Berücksichtigung der Standard-Sortierung der Spielertabelle.
	 * 
	 * @param sortierung Sortierung als enum.
	 * @return Sortierung als ORDER_BY kompatible Anweisung.
	 */
	private static String getSpielerSortierung(Sortierung sortierung) {
		String sortiertNach = SpielerTbl.DEFAULT_SORT_ORDER;
		switch (sortierung) {
		case NAME:
			sortiertNach = SpielerTbl.NAME;
			break;
		default:
			break;
		}
		return sortiertNach;
	}

	/**
	 * Lädt den Spieler aus dem SpielerTbl-Datensatz, auf dem der Cursor gerade steht.
	 * Der Cursor wird anschließend deaktiviert, da er im SpielerSpeicher nur intern als "letzter Aufruf" aufgerufen wird.
	 * 
	 * @param c aktuelle Cursorposition
	 * 
	 * @return SpielerVO
	 */
	public SpielerVO ladeSpieler(Cursor c) {
		final SpielerVO spielerVO = new SpielerVO();

		spielerVO.id = c.getLong(c.getColumnIndex(SpielerTbl.ID));
		spielerVO.key = spielerVO.id;
		spielerVO.mannschaftId = c.getLong(c.getColumnIndex(SpielerTbl.MANNSCHAFT_ID));
		spielerVO.aushelfermannschaftId = c.getLong(c.getColumnIndex(SpielerTbl.AUSHELFER_MANNSCHAFT_ID));
		
		spielerVO.name = c.getString(c.getColumnIndex(SpielerTbl.NAME));
		
		spielerVO.passNr = c.getLong(c.getColumnIndex(SpielerTbl.PASS_NR));
		spielerVO.vorname = c.getString(c.getColumnIndex(SpielerTbl.VORNAME));
		spielerVO.gebDatum = c.getString(c.getColumnIndex(SpielerTbl.GEB_DATUM));
		
		spielerVO.latidute = c.getInt(c.getColumnIndex(SpielerTbl.LOC_LATITUDE));
		spielerVO.longitude = c.getInt(c.getColumnIndex(SpielerTbl.LOC_LONGITUDE));
		
		return spielerVO;
	}

	/**
	 * Schliesst die zugrundeliegende Datenbank. Vor dem naechsten Zugriff muss oeffnen() aufgerufen werden.
	 */
	public void schliessen() {
		mDb.close();
		LOG.v(TAG, "Datenbank kegelverwaltung geschlossen.");
	}

	/**
	 * Oeffnet die Datenbank, falls sie vorher mit schliessen() geschlossen wurde.
	 * Bei Bedarf wird das Schema angelegt bzw. aktualisiert.
	 */
	public void oeffnen() {
		mDb.getReadableDatabase();
		LOG.v(TAG, "Datenbank kegelverwaltung geoeffnet.");
	}

	/**
	 * Gibt die Anzahl der Geokontakte in der Datenbank zurueck.
	 * Performanter als Cursor::getCount.
	 * 
	 * @return Anzahl der Spieler.
	 */
	public int anzahlSpieler() {
		final Cursor c = mDb.getReadableDatabase().rawQuery("select count(*) from " + SpielerTbl.TABLE_NAME, null);
		if (c.moveToFirst() == false) {
			return 0;
		}
		return c.getInt(0);
	}

}
